{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "定义一个三层的全连接网络（FCN），也叫多层感知机（MLP）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim,hidden_dim=128):\n",
    "        \"\"\" 初始化q网络，为全连接网络\n",
    "        \"\"\"\n",
    "        super(Model, self).__init__()\n",
    "        self.fc1 = nn.Linear(state_dim, hidden_dim) # 输入层\n",
    "        self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n",
    "        self.fc3 = nn.Linear(hidden_dim, action_dim) # 输出层\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # 各层对应的激活函数\n",
    "        x = F.relu(self.fc1(x)) \n",
    "        x = F.relu(self.fc2(x))\n",
    "        return self.fc3(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "经验回放主要有两个功能，一是存储样本(push)，二是随时采样样本(sample)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "\n",
    "智能体主要负责与环境交互并更新策略(模型参数)，因此首先需要定义sample_action和predict_action两个函数，前者用于训练时的采样动作，一般会采取$\\varepsilon-\\text{greedy}$策略来提高探索能力，后者一般用于测试算法时的预测动作。其次需要定义update函数，这个函数主要用来从经验回放中采样样本，然后更新模型参数。\n",
    "\n",
    "注意：\n",
    "* 每个张量的维度要对应上，否则可能会报错或者不收敛"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "from torch.distributions import Categorical\n",
    "import math\n",
    "import numpy as np\n",
    "class Policy:\n",
    "    def __init__(self,cfg):\n",
    "        self.target_update = cfg.target_update\n",
    "        self.action_dim = cfg.action_dim  \n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.gamma = cfg.gamma # 奖励的折扣因子\n",
    "        self.alpha = cfg.alpha # soft q learning中的温度参数\n",
    "        # e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end =cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.memory = ReplayBuffer(cfg.buffer_size)\n",
    "        # 当前网络和目标网络\n",
    "        self.policy_net = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        self.target_net = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        # 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "            target_param.data.copy_(param.data)\n",
    "        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) # 优化器\n",
    "        self.update_cnt = 0 # 用于延迟更新目标网络的计数\n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon指数衰减\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if random.random() > self.epsilon:\n",
    "            return self.predict_action(state)\n",
    "        else:\n",
    "            action = random.randrange(self.action_dim)\n",
    "        return action\n",
    "    \n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        q_values = self.policy_net(state)\n",
    "        values_soft = self.alpha * torch.logsumexp(q_values / self.alpha, dim=1, keepdim=True)\n",
    "        probs = F.softmax(q_values - values_soft, dim=1)\n",
    "        dist = torch.distributions.Categorical(probs)\n",
    "        action = dist.sample()\n",
    "        return action.item()\n",
    "    \n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 从经验回放中随机采样一个批量的样本\n",
    "        states, actions, rewards, next_states, dones = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        # 将数据转换为tensor\n",
    "        states = torch.tensor(np.array(states), device=self.device, dtype=torch.float) # [batch_size, state_dim]\n",
    "        actions = torch.tensor(actions, device=self.device).unsqueeze(1)  #  [batch_size, 1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1)   # [batch_size, 1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [batch_size, state_dim]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1)  # [batch_size,1]\n",
    "        # 计算当前状态(s_t,a)对应的Q值\n",
    "        q_values = self.policy_net(states).gather(dim=1, index=actions) \n",
    "        # 计算下一时刻的状态(s_t_,a)对应的Q值，注意需要detach()，因为不需要计算梯度\n",
    "        next_q_values = self.target_net(next_states)\n",
    "        next_values_soft = self.alpha * torch.logsumexp(next_q_values / self.alpha, dim=1, keepdim=True)\n",
    "        expected_q_values = rewards + self.gamma * (1-dones) * next_values_soft\n",
    "         # 计算均方根损失\n",
    "        loss = nn.MSELoss()(q_values, expected_q_values) \n",
    "        # 优化更新模型\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # clip防止梯度爆炸\n",
    "        for param in self.policy_net.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step() \n",
    "        self.update_cnt += 1\n",
    "        # 每隔一定步数更新目标网络的参数\n",
    "        if self.update_cnt % self.target_update == 0:\n",
    "            for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "                target_param.data.copy_(param.data)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "def train(cfg):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env = gym.make(cfg.env_id)\n",
    "    setattr(cfg, \"action_space\", env.action_space)\n",
    "    setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "    setattr(cfg, \"action_dim\", env.action_space.n)\n",
    "    policy = Policy(cfg)\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    frames = []\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, terminated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            policy.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        frames.append(i_ep)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{policy.epsilon:.3f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames}\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'DQN' # 算法名称\n",
    "        self.env_id = 'CartPole-v1' # 环境id\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.train_eps = 100 # 训练的回合数\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.max_steps = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        self.gamma = 0.95 # 折扣因子\n",
    "        self.alpha = 4 # soft q 的温度系数\n",
    "        self.epsilon_start = 0.95 # e-greedy策略中初始epsilon\n",
    "        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon\n",
    "        self.epsilon_decay = 500 # e-greedy策略中epsilon的衰减率\n",
    "        self.buffer_size = 100000 # 经验回放池的容量\n",
    "        self.hidden_dim = 256 # 神经网络的隐藏层维度\n",
    "        self.batch_size = 64 # 批次大小\n",
    "        self.target_update = 100 # 目标网络的更新频率\n",
    "        self.lr = 0.0001 # 学习率\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda'"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t        DQN         \t   <class 'str'>    \n",
      "       env_id       \t    CartPole-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "     train_eps      \t        100         \t   <class 'int'>    \n",
      "      test_eps      \t         20         \t   <class 'int'>    \n",
      "     max_steps      \t        200         \t   <class 'int'>    \n",
      "       gamma        \t        0.95        \t  <class 'float'>   \n",
      "       alpha        \t         4          \t   <class 'int'>    \n",
      "   epsilon_start    \t        0.95        \t  <class 'float'>   \n",
      "    epsilon_end     \t        0.01        \t  <class 'float'>   \n",
      "   epsilon_decay    \t        500         \t   <class 'int'>    \n",
      "    buffer_size     \t       100000       \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t         64         \t   <class 'int'>    \n",
      "   target_update    \t        100         \t   <class 'int'>    \n",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "       device       \t        cpu         \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/100，奖励：30.00，Epislon：0.682\n",
      "回合：20/100，奖励：14.00，Epislon：0.490\n",
      "回合：30/100，奖励：11.00，Epislon：0.346\n",
      "回合：40/100，奖励：21.00，Epislon：0.240\n",
      "回合：50/100，奖励：20.00，Epislon：0.170\n",
      "回合：60/100，奖励：52.00，Epislon：0.106\n",
      "回合：70/100，奖励：97.00，Epislon：0.036\n",
      "回合：80/100，奖励：111.00，Epislon：0.013\n",
      "回合：90/100，奖励：200.00，Epislon：0.010\n",
      "回合：100/100，奖励：200.00，Epislon：0.010\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(cfg, frames, rewards):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label='rewards')\n",
    "    plt.plot(frames, smooth(rewards), label='smoothed rewards')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n",
    "# 获取参数\n",
    "cfg = Config() \n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg)\n",
    "plot_rewards(cfg, res['frames'], res['rewards'])\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6.9 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
